import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)
import { closeConnection} from '@/websocket.js'

import { myRequest,slice_time } from '../api/ajax.js'
// 待使用订单步骤条
import orderStep from './modules/orderStep.js'
// 优惠券模块
import coupon from './modules/coupon.js'

// 奈雪的茶的store(vuex)
import menu from './modules/menu.js'

export default new Vuex.Store ({
	modules: {
		orderStep,
		menu,
		coupon
	},
	
	// 全局属性变量
	state: {
		current_version:1.9,     //版本号
		
		userInformation:{}, //用户的个人信息
		goodsInfor:[],   //所有的商品信息  [[],[]] 
		
		num_flag:0,    //标志show_menu是goodsArray的第几个元素
		allGoods:[], //所有商品信息 [{leixing:'水果',goods:[]},{leixing:'零食',goods:[]}，]
		
		user_order:[],  //用户自己的订单
		cart:[],    //购物车
		
		userSite:[],     // 用户所有地址  每个对象里有4个属性，name,phone,address,pcd
		current:-1,      // 显示的用户地址在地址列表中的索引
		
		intervalID:'',    //管理员循环获取顾客订单的ID
		cusOrderID:'',    //用户获取订单的定时器ID  循环获取商品信息的 TODO:~~~~~~~
		customer_order:[],    //商家查看的用户全部订单
		length:'',     //商家查看的用户全部订单的数量
		drxl:[],            //当日销量
		dyxl:[]             //当月销量
	},
	
	// 全局同步方法；调用方法，this.$store.commit("xxx",parameter)
	mutations: {
		//用户退出登录时清空信息
		logout_clear(state){
			state.cart=[]
			state.userInformation={}
			// state.show_user_address={}
			state.current=-1
			state.num_flag=0
			
			// 退出时候关闭连接
			closeConnection()
			// 清除定时器id,循环获取商品信息的
			clearInterval(cusOrderID)
			state.orderStep.orderStepArr = []
			state.orderStep.currentStep = -1
		},
		
		//清空购物车
		empty_cart(state){
			state.cart = []
		},
		
		//往购物车里加东西
		add_cart(state,data){
			let flag = true;
			
			state.cart.map(res=>{
				if(res.goodsID===data.goodsID){
					res.sale_number++;
					flag=false;
				}
			})
			
			if(flag){
				// data.sale_number = 1;（这又是一个坑，以这种方式直接添加属性并非响应式的）
				Vue.set(data,'sale_number',1)   //要以这种方式给对象添加属性，才是响应式的
				state.cart.push(data);
			}
			console.log("state.cart" ,state.cart)
		},
		
		//往购物车里减东西
		subtract_cart(state,data){
			let item = state.cart.find((element)=>{
				return data.goodsID==element.goodsID
			})
			
			if(item){
				item.sale_number--
				if(item.sale_number==0){
					let a=state.cart.indexOf(item)
					state.cart.splice(a,1)
				}
			}
			
			console.log("state.cart",state.cart)
		},
		
		//管理员删除商品后在购物车中也删除对应的商品
		delete_item(state,goodsID){
			let item = state.cart.find((element)=>{
				return element.goodsID==goodsID
			})
			if(item){
				let a=state.cart.indexOf(item)
				state.cart.splice(a,1)
			}
		},
		
		//顾客的全部订单
		receive_customer(state,data){
			// console.log('receive_customer',data)
			state.customer_order=data
			state.length=data.length
			
			// console.log('customer_order',state.customer_order)
			// console.log('state.customer_order')
		},
		
		
		//  获取所有商品信息 改进后
		receiveGoods(state,result){
			// 这样会报错，不知道为什么
			// for (let i = 0; i < result.length; i++) {
			// 	Vue.set(state.goodsInfo, i, result[i].goods)
			// }
			
			Vue.set(state.goodsInfor, 0, result[0].goods)
			Vue.set(state.goodsInfor, 1, result[1].goods)
			
			state.allGoods = result
			console.log('allGoods------------',state.allGoods)
		},
		
		//用户拿到自己的订单
		receive_userOrder(state,data){
			state.user_order=data
			// console.log('receive_userOrder',state.user_order)
		},
		
		//获取当日销量
		receive_drxl(state,data){
			state.drxl=data
			// console.log('receive_drxl', state.drxl)
		},
		
		//获取当月销量
		receive_dyxl(state,data){
			state.dyxl=data
			// console.log('receive_dyxl', state.dyxl)
			console.log('receive_dyxl')
		},
		
		//改进后  获取收货地址
		receive_userSite(state,data){
			state.userSite=data
			console.log('userSite',state.userSite)
			let item = state.userSite.find((element,index,arr) => {
				return element.isdefault==1
			})
			
			if(item){
				state.current = state.userSite.indexOf(item)
			}
		},
		
		//删除地址后current的变化
		change_current(state,i){
			if(state.current==i){
				state._current=-1
			}else if(state._current<i){
				
			}else if(state._current>i){
				state._current--
			}
		}
	},
	
	// 异步方法；调用方法，this.$store.dispatch("xxx")
	actions: {
		//管理员获取用户的全部订单
		async getCusOrder(context,obj){
			console.log('getCusOrder = ',obj.amount)
			
			let result=await myRequest({
				url:'/supermarket/dd/adminjk'
			}) 
			result.reverse()
			// console.log(result)
			
			//根据jysj（结算时间）把一维数组转换成二维数组
			let arrayTwo = Object.values(result.reduce((res, item) => {
			  res[item.jysj] ? res[item.jysj].push(item) : res[item.jysj] = [item];
			  return res;
			}, {}));
			// console.log('arrayTwo',arrayTwo)
			
			//根据用户ID(userID) 把二维数组转换成三维数组  （数组的map方法不会改变原有数组，可以返回一个新数组)
			let arrayThree = arrayTwo.map(item=>{
				return item = Object.values(item.reduce((res, item_item) => {
				  res[item_item.userID] ? res[item_item.userID].push(item_item) : res[item_item.userID] = [item_item];
				  return res;
				}, {}));
				// console.log('item',item)
				
			})
			
			//3维降2维
			let aTwo= arrayThree.reduce((a,b)=>{ return a.concat(b)})
			
			//最终的形式，数组中的每个元素是对象，对象的goods属性值是数组（map方法会将数组映射成一个新的数组，不会改变原有数组）
			let final_aTwo = aTwo.map(item=>{
				return item = item.reduce((obj,element,index,arr)=>{
					if(!obj['jysj']){
						obj['jysj']=element.jysj
					}
					if(!obj['psdz']){
						obj['psdz']=element.psdz
					}
					if(!obj['goods']){
						obj['goods']=arr
					}
					obj['sum_money']?obj['sum_money'] += element.ddze:obj['sum_money']=element.ddze
					return obj
				},{})
			})
			
			// console.log('final_aTwo',final_aTwo)
			context.commit('receive_customer',final_aTwo)
		},
		
		//用户获取自己的订单getUserOrder
		async getUserOrder(context){
			// console.log('getUserOrder')
			// 用户查看个人订单
			/* let order = await myRequest({
				url:'/supermarket/dd/grddb',
				data:{
					userID:context.state.userInformation.userID
				}
			})
			order.reverse()
			//根据交易时间把1维数组变成2维数组[[],[],[]]
			let arrayTwo = Object.values(order.reduce((res, item) => {
			  res[item.jysj] ? res[item.jysj].push(item) : res[item.jysj] = [item];
			  return res;
			}, {}));
			
			//2维降1维，[[],[],[]] => [{goods:[] ,sum_money:''},{}]
			let arrayOne = arrayTwo.map(item=>{
				return item.reduce((obj,element,index,arr)=>{
					if(!obj['goods']){
						obj['goods']=arr
					}
					if(!obj['jysj']){
						obj['jysj']=element.jysj
					}
					obj['sum_money']?obj['sum_money'] += element.ddze:obj['sum_money']=element.ddze
					return obj
				},{})
			}) */
			
			let userOrder = await myRequest({
				url: '/supermarket/dd/payedOrder/' + context.state.userInformation.userID
			})
			userOrder = userOrder.reverse()
			// console.log('userOrder ==== ', userOrder)
			
			context.commit('receive_userOrder',userOrder)
		},
		
	
		
		//获取商品信息（改进）
		async get_goods(context){
			let result = await myRequest({
				url:'/allgoods'
			})
			
			let type = Object.keys(result)
			let list = Object.values(result)
			let num = type.length
			let arr = new Array(num)
			//foreach和map不会对空数组检测
			for(let k=0;k<arr.length;k++){
				arr[k] = {}
				arr[k].leixing = type[k]
				arr[k].goods = list[k]
			}
			
			console.log('get_goods',arr)
			context.commit('receiveGoods',arr)
		},
		
		//获取当日销量
		async get_drxl(context){
			let result=await myRequest({
				url:'/supermarket/dd/ncxdrxl'
			})
			context.commit('receive_drxl',result)
		},
		
		//获取当月销量
		async get_dyxl(context,parameter){
			console.log('parameter',parameter)
			let result = await myRequest({
				url:'/supermarket/dd/cxtdxlb/'+parameter
			})
			context.commit('receive_dyxl',result)
		},
		
		//用户获取所有收获地址
		async get_userSite(context,id){
			const result = await myRequest({
				url:'/supermarket/userlogin/cxuseraddress/'+id//要改
			})
			console.log("get_userSite------------------", result)
			let res = result.map((element,index,arr) => {
				let obj={}
				obj.name = element.receivername
				obj.phone =element.receiverphone
				obj.address = element.receiveraddress
				obj.isdefault = element.isdefault
				obj.sid = element.sid
				//pcd:province-city-district 省市区
				obj.pcd = element.receiverprovince + ' '+element.receivercity+' ' + element.receiverdistrict
				return obj
			})
			
			context.commit('receive_userSite',res)
		}
	},
	
	// vuex属性计算，在视图里当变量使用
	getters: {
		//查看某种类型的商品的购买数量，例如水果买了多少，
		count(state){
			// 这个函数的执行依赖一个可变的变量
			return (i)=>{
				return state.cart.reduce((num,element,index,arr)=>{
					if(element.spxxbh==i){
						num += element.sale_number
					}
					return num
				},0)
			}
		},
		
		//每件商品在界面显示的购买数量  -【show_num】+  例如香蕉上面显示购买的数量是几
		show_num(state){
			return (shop_info)=>{
				let obj = state.cart.find((element)=>{
					return shop_info.goodsID==element.goodsID
					
				})
				
				return obj?obj.sale_number:0
			}
		},
		
		//总价
		totalPrice(state){
			let total = state.cart.reduce((sum,element)=>{
				sum += element.spdj*element.sale_number
				return sum
			},0)
			return total.toFixed(2)
		},
		
		//管理员在商品管理那页，所遍历的数组
		goods(state){
			let arrOne= state.goodsInfor.reduce((res,element)=>{
				return res.concat(element)
			},[])
			
			return arrOne
		},
		
		//show_menu:{leixing:'',goods:[]}, //在福润隆超市主页面显示的列表
		show_menu(state){
			// return state.goodsArray[state.num_flag]
			let k = []
			// console.log('kkkkk',k[0])
			return state.allGoods[state.num_flag]
		},
		
		//要显示的收货地址
		show_userSite(state,getters){
			return  state.userSite[state.current]
		}
	},
})


